package cn.good.yan.b6;

import java.util.*;
import java.util.stream.Collectors;

/**
 *  b6  集合 + Map
 *      1 集合基础
 *      2 Collections 工具类
 *      3 CollectionUtils 工具类
 *      4 Map 操作
 *      5 List 操作
 * @author shengren.yan
 * @create 2023-07-20
 */
public class Test {

    /**
     *  1 集合基础：
     *  Conllection - List （有序） - Set （无序）
     *     List - ArrayList （查询快-底层数组 - 因为数组在内存空间是连续的）
     *          - Vector 线程安全，效率低
     *          - LinkedList（查询慢-增删快，底层链表）
     *     Set  - HashSet （判断元素是否存在 - 先比较hashcode,若不在 再比较equals进行比较内容 ）
     *                 jdk1.7 数组 + 链表   jdk1.8 数组 + 链表 + 红黑树
     *                 数组默认长度是16 链表 大于7（8）变成红黑树  加载因子是0.75
     *          - TreeSet 拥有指定排序方式
     *            HashSet  - LinkHashSet （多了维护链表元素的顺序，遍历效率高于HashSet，增删慢）
     *     Map - HashMap
     *         - Hashtable （线程安全，不能有null作为key）
     *         - TreeMap 根据key自然排序
     *                   自然排序 Comparable接口   定制排序 Comparator接口
     *           HashMap - LinkedHashMap （多了维护链表元素的顺序，遍历效率高于HashMap，增删慢）
     */
    public void t1() {
        // 数组转list
        List<Integer> integers = Arrays.asList(1, 2, 3);
        // list转数组
        Integer[] objects = (Integer[]) integers.toArray();
        // 是否为空
        boolean empty = integers.isEmpty();
        // 新增
        // integers.add();  integers.addAll();
        // 是否包含aa
        boolean aa = integers.contains("aa");
        boolean aa2 = integers.containsAll(new ArrayList<>());
        // 清空
        integers.clear();
        //  删除  - 如果是对象，需要重新equals方法
        integers.remove("aa");
        // 两个集合 取交集
        integers.retainAll(integers);
        // 截取集合1-3位置的数据，包含头，不包含尾
        List<Integer> integers1 = integers.subList(1, 3);
        // 返回该元素在集合中的小标
        int i = integers.indexOf(2);
        // 返回该元素在集合中的小标 （从后面查）
        int i2 = integers.lastIndexOf(2);

        // LinkedList 的方法
        LinkedList<Integer> integers2 = new LinkedList<>();
        integers2.addFirst(1);
        integers2.getFirst();  integers2.getLast();
        integers2.removeFirst();
        // 堆栈：先进后出  队列：先进先出
    }

    /**
     *  2 Collections 工具类
     */
    public void t2() {
        List<Integer> integers1 = Arrays.asList(1, 2, 3);
        // list反转
        Collections.reverse(integers1);
        // list随机顺序
        Collections.shuffle(integers1);
        // 自然排序  参数2 定义排序，传递Comparator
        Collections.sort(integers1);
        Collections.sort(integers1, (a, b) -> {
            return Integer.compare(a, b);
        });
        // 位置交换，将1和3的位置交换
        Collections.swap(integers1, 1, 3);
        // 最大值 ，参数2,传递Comparator 按照这个方式比较
        Integer max = Collections.max(integers1);
        Integer max1 = Collections.max(integers1, (a, b) -> {
            return a.compareTo(b);
        });
        // 最小值， 同上
        Collections.min(integers1);
        // 该list中出现"AA"的次数
        int aa1 = Collections.frequency(integers1, "AA");
        // 将list中的全部的3替换成4。替换所有的旧值
        Collections.replaceAll(integers1, 3, 4);
        // list 复制
        Collections.copy(integers1, new ArrayList<>(integers1.size()));

        // 只读的List (不能写)
        List<Integer> integers = Collections.unmodifiableList(integers1);
        // 线程安全的List
        List<Integer> integers2 = Collections.synchronizedList(integers);
    }

    /**
     *  3 CollectionUtils 工具类
     *  需要引包
     *  <dependency>
     *     <groupId>org.apache.commons</groupId>
     *     <artifactId>commons-collections4</artifactId>
     *     <version>4.4</version>
     * </dependency>
     */
    public void t3() {
//        List<String> list = Arrays.asList("a", "b", "c");
//        List<String> lists = Arrays.asList("a", "d", "c");
//        // 两个集合取交集
//        Collection collection = CollectionUtils.retainAll(list, lists);
//        // 两个集合取并集
//        Collection collection1 = CollectionUtils.union(list, lists);
//        // 两个集合取差集 就是只有lists里面有的元素
//        Collection collection2= CollectionUtils.subtract(lists, list);
//        System.out.println(collection);
//        System.out.println(collection1);
//        System.out.println(collection2);
    }

    /**
     * 4 Map 操作
     * 需要引包
     * <dependency>
     *     <groupId>commons-beanutils</groupId>
     *     <artifactId>commons-beanutils</artifactId>
     *     <version>1.9.4</version>
     * </dependency>
     */
    public void t4() {
        Map<String, String> map = new HashMap<>();
        // 添加、修改
        map.put("k1","Tom");
        map.putAll(new HashMap<>());
        // 删除
        map.remove("k1");
        // 查
        map.get("k1");
        // 长度
        int size = map.size();
        // 是否包含当前的key
        boolean k1 = map.containsKey("k1");
        // 是否包含当前的Value
        boolean k2 = map.containsValue("Tom");
        // 是否为空
        boolean empty = map.isEmpty();
        // 遍历出全部的key
        Set<String> strings = map.keySet();
        // 遍历出全部的Value
        Collection<String> values = map.values();
        // 遍历出全部的
        Set<Map.Entry<String, String>> entries = map.entrySet();
        entries.forEach(x -> {
            // key + value
            System.out.println(x.getKey() + x.getValue());
        });
//        实体 kyrei = new 实体("kyrei", 12);
//        // 对象转map
//        Map<String, String> describe = BeanUtils.describe(kyrei);
//        // map转对象
//        实体 user1 = new 实体();
//        BeanUtils.populate(user1,describe);
//        System.out.println(user);
    }

    /**
     * 5 List 操作
     */
    public void t5() {
//        // 数组转集合
//        List<String> list = Arrays.asList(StringUtils.split("1,2,3", ","));
//        // 集合操作
//        List<DictElementByRoleVo> collect = list.stream().map(x -> {
//            DictElementByRoleVo vo = new DictElementByRoleVo();
//            vo.setRoleId(1L);
//            vo.setDictIds(x);
//            return vo;
//        }).collect(Collectors.toList());
//        //  list转字符串
//        String abc = StringUtil.join(nameList, ",");
    }


    /**
     * 5 Set 操作 （无序）
     */
    public void t6() {
        Set<String> strings = new HashSet<>();
        strings.add("a");
        strings.add("b");

    }


}
